﻿﻿/**
 * 远光ECP平台3.0版本 http://www.ygsoft.com/ Grace [Gris Application Cloud-Computing
 * Extension]
 * 
 * 构建数字验证框控件类
 * 
 * 变更版本：
 * zhengxianwei@ygsoft.com 2016-05-03 创建
 */
define(["jquery","ecp.utils","jquery.migrate","ecp.component.popover", "ecp.const","ecp.utils.i18n"],function($,utils,migrate,popover,ecpconst,i18n){
	/**
	 * 默认参数.
	 */
	var defaultOptions = {
		requireMsg : i18n.numbox.requireMsg,
		errorMaskMsg : i18n.numbox.errorMaskMsg,
		popoverOption: {
			placement:"bottom"
		}
	};
	
	/**
	 * 声明numberBox对象
	 */
	var NumberBox = function(control,options){
		if(!control || control.length === 0){return;}
		this.init(control,options);
		this.render();
	}
	
	/**
	 * 通过原型定义相关方法，比如渲染、赋值等等.
	 */
	NumberBox.prototype = {
		
		/**
	     * 初始化控件
	     * 
	     * @param {Selector} control 控件
	     * @option {Object} option 配置参数
	     */
		init : function(control, option){
			if(control && control.length === 0){return;}
			this.control = control;
			var dataOpt = control.attr("data-option");
			if(dataOpt && dataOpt.length !== 0){
					dataOpt = $.parseJSON(dataOpt);
				}else{
					dataOpt = {};
				}
			this.option = $.extend(true,{},defaultOptions,dataOpt,option);
		},
		
		/**
		 * 渲染控件。
		 */
		render : function(){		
		
			var me = this,
				option = me.option,
				control = me.control,
				_mask = option.mask,
				_isErrorMask,_timer;

			//设置了掩码和显示格式，那么显示格式优先级要高
			if(_mask && option.format){
				option.mask = null;
				_mask = null;
			}
			//校验mask是否设置正确，即掩码是否符合要求
			if (utils.notEmpty(_mask) && $.trim(_mask).length !== 0) {
				var _regExp = new RegExp("^([^-*,#.]+)?([*]?-?#{1,3})(,###)*(\.#+)?$","g");
				_isErrorMask = _regExp.test(_mask);
			}
			//渲染提示控件
			popover.ecpPopover(control,option.popoverOption);
			if(utils.notEmpty(_isErrorMask) && _isErrorMask == false){
				
				_timer = setTimeout(function(){
					control.attr("disabled", true);
					control.css("background-color", "#D3D3D3");
					//生成错误提示信息
					me.addErrorMsg(option.errorMaskMsg);
				},200);
				
			}else{
				//禁用输入法
				control.css("ime-mode","disabled");
				
				//绑定keyPress事件，校验数字
				control.bind("keypress",function(event) {
										
					me.keypressValidate(event);
					
				}).bind("keydown",function(event) {//绑定keydown事件
					
					return me.verifyCopyAndDel(event);
					
				}).bind("keyup",function(event) {//绑定keyup事件
					//解决IE下，手动执行change事件后获得的控制值为旧值
					if($.browser.msie && me.ieStopDo === true){
						delete me.ieStopDo;
					}
					me.keyupValidate(event);
					
				}).bind("blur",function() {//绑定失去焦点执行事件，处理小数点前后、只有一个负号、最大值最小值等情况
					//win10下自带输入法键盘事件不会校验输入值，这里重新做校验
					var regExp = new RegExp("[^-|.|0-9]");
					if(regExp.test(control.val().trim())){
						me.value("");
					}
					//解决IE下，手动执行change事件后获得的控制值为旧值
					if($.browser.msie && me.ieStopDo === true){
						return;
					}
					me.doBlur = true;
					//不能为空
					me.verifyRequired(true);
					
					//小数点处在第一位补零处理
					me.doDecimalBeforeAddZero();
					
					//输入框只有一个负号的处理
					me.verifyOnlyMinus(); 
				
					//最小值校验
					me.verifyMin();
					
					var val = control.val();
					//小数部分不够补零的校验
					val = me.verifyDecimalDigit(val);
					var cf = option.chineseFormat;
					if(cf || option.format){
						val = me.removeThousandsSeparator();
						me.formatOrgVal = val;
						if(cf){
							switch(cf){
								case "upper" : 
									val = utils.transferNumToChUpper(val);
									break;
								case "lower" :
									val = utils.transferNumToChLower(val);
									break;
								case "money" :
									val = utils.transferNumToMoney(val);
									break;
							}
						}else{
							val = utils.formatData(option.format, val);
						}
						
					}else{
						//设置千分位
						val = me.addThousandsSeparator(val);
						
						//金额货币处理
						val = me.addMoneyCurrency(val);
					}
					
					me.value(val);
					
					//对齐方式
					me.textAlign(true);
					
					me.doBlur = false;
					
				}).bind("contextmenu",function(event) {//绑定contextMenu(右键菜单)事件，处理复制和粘贴的问题
					
					return me.shieldContextMenu(event);
					
				}).bind("focus",function(event) {//绑定focus事件
					//解决IE下，手动执行change事件后获得的控制值为旧值
					if($.browser.msie && me.ieStopDo === true){
						return;
					}
					me.addErrorMsg("","hide");
					//移除千分位
					me.removeThousandsSeparator();
					
					//移除货币符号
					me.removeMoneyCurrency();

					//移除小数位都为0的情况
					
					if((option.chineseFormat || option.format) && me.formatOrgVal){
						control.val(me.formatOrgVal);
					}
					//设置光标放置在文本框内容的最后面(处理IE在获得焦点后光标默认停在第一位的问题，当数据为空不存在这样的问题)
					if($.browser.msie){
						var pos = utils.getCursorPosition(event),
							start = utils.notEmpty(pos) ? pos.start : 0; 
						utils.setCursorPosition(this,start==0 ? this.value.length : start);
					}
					
					//移除对齐方式
					me.textAlign(false);
					
				});
			}
			control.attr("ecpclass",ecpconst.EcpClass.NUMBERBOX);
		},
		
		/**
		 * keyup校验
		 */
		keyupValidate: function(event){
			 var isValidate,
				me = this,
				control = me.control,
				evt = event || window.event,
				kc = evt.which;
			if (me.ctrlKey==true) {//处理复制和粘贴问题
				delete me.ctrlKey;
				isValidate = me.validateNumber(evt);
				if(!isValidate){
					me.value(me.orgVal || "");
					delete me.orgVal;
				}
			} else {
				isValidate = me.validateNumber(evt);
				if(!isValidate){
					me.value(me.orgVal || "");
				}else{
					me.orgVal = control.val();
				}
			}
		},
		/**
		 * keypress校验
		 * @param event事件名称
		 * @return void
		 */
		keypressValidate : function(event){
			 
			var disableReadonly,isValidate,
				me = this,
				control = me.control,
				evt = event || window.event,
				kc = evt.which;
			//IE用disabled，firefox用readOnly，用于处理禁止输入非法字符
			disableReadonly = $.browser.msie ? "disabled" : "readOnly";
							
			if (evt.ctrlKey==true&&(kc==99||kc==118)) {//firefox处理复制和粘贴问题
				
				isValidate = me.validateNumber(evt,false,true);
			} else if(kc == 8) {//处理退格键（firefox）
									
				isValidate = me.validateNumber(evt,true);
			} else {
				
				isValidate = me.validateNumber(evt,false);
			}
			if(isValidate && control.attr("data-content") == me.option.requireMsg){
				this.addErrorMsg("");
			}
			//通过设置元素的disabled(IE)或者readOnly(FF)来控制输入权限
			if (!((kc>=48 && kc<=57 && evt.ctrlKey==false && evt.shiftKey==false)||kc==0||kc==8
					||kc==45||kc==46||(evt.ctrlKey==true&&(kc==99||kc==118)) )||!isValidate) {
				
				control.attr(disableReadonly,true);
				
				//通过定时器来解除文本框的输入权限
				setTimeout(function(){
					control.removeAttr(disableReadonly);
					//IE需要获得焦点
					if($.browser.msie){
						control.focus();
						me.ieStopDo = true;
						//解决ie10下，禁止输入时不触发change事件
						control.trigger("change");
					}
				},0);
			}
		},
		
		/**
		 * 数字校验，作为公共校验的方法
		 * 校验最大值
		 * @param e 必选项，元素事件名称
		 * @param isDel 可选项，是否执行数字键盘的Del按键，true执行，false不执行
		 * @param isCopy 可选项，是否处理复制和粘贴，true处理，false不处理
		 * @return isValidate 是否通过校验，true通过，false不通过
		 */
		validateNumber : function(e,isDel,isCopy) {
			
			var kc,regExp,isValidate,cursorPosition,newVal,
				kcToVal = "",
				intDigit = "",
				dicDigit = "",
				evt = e || window.event,
				me = this,
				control = me.control,
				option = me.option,
				v = control.val(),
				mask = option.mask;
			//与原值不变时返回true
			//if(me.orgVal == v){return true;}
			if (utils.notEmpty(mask) && $.trim(mask).length !== 0) {
				intDigit = me.parseDigit(mask).integerDigits;
				if (!utils.notEmpty(intDigit) || $.trim(intDigit).length === 0) {
					intDigit = ""
				} else {
					if (typeof(intDigit) === "string") {
						intDigit = parseInt(intDigit);
					}
					intDigit = intDigit - 1;
				}
				dicDigit = me.parseDigit(mask).decimalDigits;
			}
			regExp = new RegExp("^(([-]?)|([-]?[0])|([-]?[1-9]\\d{0,"+intDigit+"}))(\\.\\d{0,"+dicDigit+"})?$");
			
			kc = evt.which;
			
			//获得光标所在文本框内容的位置
			cursorPosition = utils.getCursorPosition(evt);
			
			if(e.type !== "keyup"){
				//通过事件的keyCode或which来获得键盘中按键对应的实际值
				kcToVal = String.fromCharCode(kc);
			}
			//解决了Firefox退格键不能用，主要是Firefox下退格键参与了数字校验，IE\Chrome则不会。并处理Delete键；
			if (kc==8 || kc==0 || isDel == true) {
				kcToVal = "";
			}
			
			//校验剪贴板的内容是否合法
			if (isCopy == true) {
				kcToVal = utils.doGetClipboard();
			}
			
			//获得 键盘按键实际值 插入文本框中指定光标位置之后的文本框的值
			newVal = me.insertCharToStr(v,cursorPosition,kcToVal,isDel,kc);
			isValidate = regExp.test(newVal);
			//最大长度不能超过16位
			if(isValidate){
				if((""+newVal).replaceAll("[-|.]","").length > 16){
					isValidate = false;
				}
			}
			//判断最小值
			if(isValidate){
				var max = option.max;
				newVal = +newVal;
				if(max < newVal){
					isValidate = false;
				}
			}
			return isValidate;
		},
		
		/**
		 *在字符串中插入值
		 *@param str	必选项，文本框中的字符串
		 *@param position	必选项，光标所在字符串中的位置对象，包括开始位置和结束位置
		 *@param v	必选项，按键的键值
		 *@param isDel	可选项，是否执行delete按键
		 *@param kc 可选项，键盘的Unicode
		 *@return res 返回插入值后的字符串
		 */
		insertCharToStr : function(str,position,v,isDel,kc) {
			
			var res,len,_index,
				start = position.start,
				end = position.end;
			if (!utils.notEmpty(str) || $.trim(str).length === 0) {
				res = v;	
			} else {
				//onkeydown事件处理delete按键和退格键
				if (isDel === true) {
					if(kc == 46){	end ++;	}
					if(kc == 8){	start --;	}
				}
				len = str.length;
				if (start === end) {//没有选中文本
					if (end === 0) {//光标在字符串前面
						res = v + str;
					} else if (start === len) {//光标在字符串后面
						res = str + v;
					} else {//光标在字符串中间
						var s = str.slice(0,start),
							e = str.slice(start);
						res = s + v + e;
					}
				} else {//选中了文本
					var s = str.slice(0,start),
						e = str.slice(end);
					res = s + v + e;
				}
			}
			
			return res;
		},

		/**
		 *keyDown执行的事件方法，删除小数点校验、复制和粘贴
		 *@param e 必选项，元素事件名称
		 *@return boolean true或false
		 */
		verifyCopyAndDel : function(e) {
			
			var isValidate,
				evt = e || window.event,
				kc = evt.which,
				me = this,
				control = me.control,
				v = me.control.val();
			//处理delete键,其对应的键值是"."，而数字键盘中的Del键对应的键值是"n";
			var kcfcc = String.fromCharCode(kc);
			if (($.browser.msie && kc == 8) || (kc == 46 && kcfcc==".")) {
				isValidate = me.validateNumber(evt,true);
				if (isValidate) {	return true;	}
				else {	return false;	}
			}
			if(kc == 86 && evt.ctrlKey==true){
				this.ctrlKey = evt.ctrlKey;
				this.orgVal = v;
				return true;
			}
			//处理复杂和粘贴的问题(IE)
			if ($.browser.msie) {
				if (evt.ctrlKey==true && kcfcc.toLowerCase() == "v") {
					isValidate = me.validateNumber(evt,false,true);
					if (isValidate) {	return true;	}
					else {	return false;	}
				}
			}
		},
				
		/**
		 * 处理输入框为空的情况，控件required为true则增加提示图标及信息
		 * @param isBlur 是否为失去焦点时的事件，true是，false否,主要用于处理数据模型设值
		 * @return void
		 */
		verifyRequired : function(isBlur) {
			
			var me = this,
				control = me.control,
				option = me.option,
				v = control.val(),
				required = option.required,
				dataModelVal = option.dataModelValue;
			if ($.trim(v).length === 0) {
				//为空时是否设置提示信息
				if (utils.notEmpty(required) && $.trim(required).length !== 0) {
					if (typeof(required) === "string") {
						required = Boolean(required);
					}
					
					if (required == true && (control.attr("data-content") !== option.requireMsg)) {
						//添加提示信息
						me.addErrorMsg(option.requireMsg);
					}
				}
				if(isBlur){
					//为空时设置数据模型的值
					if(!utils.notEmpty(dataModelVal)){
						dataModelVal = null;
					}
					control.data("value",dataModelVal);
				}
			}
		},
		
		/**
    	 * 设置样式.
    	 * @example 1
    	 * numberBox.setStyle("backgroundColor","red");
    	 * @example 2
    	 * numberBox.setStyle({"backgroundColor":"red"});
    	 * 
    	 * @param {String | Object} styNm 为字符串时表示样式名，为object时是样式对象
    	 * @param {String} val 样式的值
    	 * 
    	 */
    	setStyle : function(styNm, val){
    		if(!styNm){return;}
    		var res = {};
    		if(typeof styNm === "string"){
    			res[styNm] = val;
    		}else if(typeof styNm === "object"){
    			res = styNm;
    		}
    		if(!$.isEmptyObject(res)){
    			this.control.css(res);
    		}
    	},
				
		/**
		 * 增加错误提示信息
		 * @return void
		 */
		addErrorMsg : function(msg, display) {
			
			var me = this,
				option = me.option,
				control = me.control,
				misMsg = option.missingMessage;
			//添加警示图标
			if(control.attr("data-content") != msg){
				if(misMsg){
					msg = misMsg;
				}
				control.attr("data-content",msg);
			}
			if(display){
				control.popover(display);
			}else{
				control.popover("toggle");
			}
		},
				
		/**
		 * 处理小数点处在第一位补零
		 * @return void
		 */
		doDecimalBeforeAddZero : function() {
			
			var res,me=this,
				control = me.control,
				v = control.val();
			if ($.trim(v).length !== 0) {
				var decIndex = v.indexOf("."),
					minusIndex = v.indexOf("-");
				if (minusIndex < 0 && decIndex === 0) {
					res = "0" + v;
				}else if (minusIndex === 0 && decIndex === 1) {
					res = "-0" + v.substring(1);
				}else{
					res = v;
				}
				me.value(res);
			}
		},
				
		/**
		 * 校验小数部分不够补零
		 * @return void
		 */
		verifyDecimalDigit : function(v) {
			
			var dicDigit,
				me = this,
				control = me.control,
				option = me.option,
//				v = control.val(),
				mask = option.mask;
			if($.trim(v).length === 0)return v;
			if (utils.notEmpty(mask) && $.trim(mask).length !== 0) {
				dicDigit = me.parseDigit(mask).decimalDigits;
			}
			var res = me.addDicZero(v,dicDigit);
			return res;
//			me.value(res);
		},
				
		/**
		 * 校验 值就是一个负号，将负号改为零
		 * @return void
		 */
		verifyOnlyMinus : function() {
			
			var me = this,
				control = me.control,
				v = control.val();
			if (v == "-") {
				var res = "0";
				me.value(res);
			}
		},
					 
		/**
		 * 校验最小值
		 * @return void
		 */
		verifyMin : function() {
			
			var me = this,
				control = me.control,
				option = me.option,
				v = control.val(),
				min = option.min;
				
			//当输入框的值为空时，在存在最小值时则取最小值
			if ($.trim(v).length !== 0) {
				if (typeof(v) == "string") {
					v = parseFloat(v);
				}
				//处理浮点数的精度问题
				var frv = utils.getFloatRoundVal(v);
				if (utils.notEmpty(min) && $.trim(min).length !== 0) {
					if (typeof(min) == "string") {
						min = parseFloat(min);
					}
					if (frv < min) {
						me.value(min);
					}
				}
//				if (utils.notEmpty(max) && $.trim(max).length !== 0) {
//					if (typeof(max) == "string") {
//						max = parseFloat(max);
//					}
//					if (frv > max) {
//						me.value(max);
//					}
//				}
			}
		},
				
		/**
		 * 屏蔽鼠标右键菜单的粘贴
		 * @param e 必选项，元素事件名称
		 * @return boolean true不屏蔽，false屏蔽
		 */
		shieldContextMenu : function(e) {
			
			var isValidate,
				evt = e || window.event;
			isValidate = this.validateNumber(evt,false,true);
			if (isValidate) {	return true;	}
			else {	return false;	}
		},
					
		/**
		 * 小数点后补零(小数位数不够)
		 * @param v 必选项，输入框中的值
		 * @param dicDigit 必选项，小数位数
		 * @return res 小数点补零的结果
		 */
		addDicZero : function(v,dicDigit) {
			
			var me = this,
				res = "";
			if (!utils.notEmpty(dicDigit) || $.trim(dicDigit).length === 0) {
				
				return v;
			} else if (dicDigit == 0) {//不存在小数位数
				
				if (utils.notEmpty(v) && $.trim(v).length !== 0) {
					var index = v.indexOf(".");
					res = index < 0 ? v : v.substring(0,index);
				}
			} else {//存在小数位数
				//如果值加上小数位大于16位时直接往前补上小数位，多出的截取掉
				if((""+v).replaceAll("[-|.|,]","").length + dicDigit > 16){
					res = (""+v).replaceAll("[-|.|,]","") + me.numToZero(dicDigit);
					res = res.substring(0,16).insert(".",16-dicDigit);
				}else{
					if (utils.notEmpty(v) && $.trim(v).length !== 0) {
						var index = v.indexOf(".");
						if (index < 0) {
							res = v + "." + me.numToZero(dicDigit);
						} else {
							var _v = v.substring(index+1),
								len = dicDigit - _v.length;
							res = len > 0 ? v + me.numToZero(len) : v;
						}
					}
				}
			}
			return res;
		},
				
		/**
		 * 有几个数字就有几个零
		 * @param num 必选项，数字个数
		 * @return res 由零组成的字符串
		 */
		numToZero : function(num) {
			
			if(!utils.notEmpty(num) || num === 0) return "";
			var res = "";
			for(var i=0; i<num; i++) {
				res += "0"; 
			}
			
			return res;
		},
		
		/**
		 * 设置千分位
		 * @return void
		 */
		addThousandsSeparator : function(v){
			
			var me = this,
				control = me.control,
				option = me.option,
				thoSep = option.thousandsSeparator;
//				v = control.val();
			//判断是否取消千分位
			if (utils.notEmpty(thoSep) && thoSep == false) return v;
			if ($.trim(v).length === 0) return v;
			var intStr,intStrLen;
			//移除千分位字符
			v = me.removeCharFromString(v,",");
			var index = v.indexOf(".");
			intStr = index < 0 ? v : v.substring(0,index);
			intStrLen = intStr.length;
			if (intStrLen > 3) {
				var fsBool=false;
				if(intStr.indexOf("-")==0){
					fsBool = true;
					intStr = intStr.substring(1);
				}
				//取反字符串
				var vReverse = utils.stringReverse(intStr),
					newStr = "", res = "", mark = "";
				//在千分位中插入逗号
				for (var i=0; i<intStrLen; i++) {
					if ((i+1)%3 === 0) {
						var vrca = vReverse.charAt(i+1);
						if (vrca && vrca !=",") {
							mark = ",";
						}
					}
					newStr += vReverse.charAt(i) + mark;
					mark = "";
				}
				//取反字符串
				res = utils.stringReverse(newStr);
				if(index > 0){
					res += v.substring(index);
				}
				if(fsBool){
					res = "-"+res;
				}
				return res;
//				me.value(res);
			}
			return v;
		},
				
		/**
		 * 移除千分位
		 * 如果value存在，就优先取value，不存在，就取control.val()
		 * @param {String} value 值
		 * @return res
		 */
		removeThousandsSeparator : function(value) {
			
			var me = this,
				control = me.control,
				option = me.option,
				thoSep = option.thousandsSeparator,
				v = value || control.val();
			//判断是否取消千分位
			if (thoSep !== undefined && thoSep == false) return;
			if ($.trim(v).length === 0) return;
			var res = me.removeCharFromString(v,",");
			control.val(res);
			return res;
//			me.value(res);
		},
		
		/**
		 * 移除字符串中给定的单个字符
		 * @param v 必选项，要处理的字符串
		 * @param c 必选项，要移除的字符
		 * @return res 移除c的字符串结果
		 */
		removeCharFromString : function(v,c){
			 
			 if(!utils.notEmpty(v) || $.trim(v).length === 0)return;
			 if(!utils.notEmpty(c) || $.trim(c).length === 0)return v;
			 var _c, res = "", index = v.indexOf(c);
			 if(index < 0)return v;
			 for (var i=0,j=v.length; i<j; i++) {
				 _c = v.charAt(i);
				 if (_c == c) continue;
				 res += _c;
			 }
			
			 return res;
		 },
			
		/**
		 * 设置金额货币符号
		 * @return void
		 */
		addMoneyCurrency : function(v) {
			
			var me = this,
				option = me.option,
				control = me.control,
				mask = option.mask;
//				v = control.val();
			if ($.trim(v).length === 0) return v;
			if (!utils.notEmpty(mask) || $.trim(mask).length === 0) return v;
			var _currency,
				ind = mask.indexOf("*"),
				_ind = mask.indexOf("#");
			if(ind >= 0){
				_currency = mask.substring(0,ind);
			}else if(_ind >= 0){
				_currency = mask.substring(0,_ind);
			}
			if (_currency != "#" && _currency != "*" && _currency != ".") {
//				me.value(_currency + v);
				if (!control.currency) {
					control.currency = _currency;
				}
				return _currency + v;
			}
			return v;
		},
				
		/**
		 * 移除金额货币符号
		 * @param void
		 */
		removeMoneyCurrency : function(){
			
			var me = this,
				control = me.control,
				currency = control.currency,
				v = control.val();
			if ($.trim(v).length === 0) return;
			if (currency) {
				var len = currency.length,
					res = v.substring(len);
				me.value(res);
				control.currency = null;
			}
		},
					
		/**
		 * 获得整数和小数部分的位数，##,###,###.##
		 * @param v 必选项，输入框的值
		 * @return digit 数字位数对象，由整数和小数组成
		 */
		parseDigit : function(v) {
			
			if (!utils.notEmpty(v) || v.length === 0) return null;
			var me = this,
				decimal = v.indexOf("."),
				asterisk = v.indexOf("*"),
				integerDigits = "",
				decimalDigits = "",
				digit = [];
			if (decimal < 0) {
				if (asterisk < 0) {//整数长度有限制
					integerDigits = me.charTime(v,"#");
				}
				decimalDigits = 0;
			} else {
				if (asterisk < 0) {//整数长度有限制
					integerDigits = me.charTime(v.substring(0,decimal),"#");
				}
				decimalDigits = me.charTime(v.substring(decimal),"#");
			}
			digit.integerDigits = integerDigits;
			digit.decimalDigits = decimalDigits;
			return digit;
		},
				
		/**
		 * 字符串中出现指定字符的次数
		 * @param v 必选项，数字字符串
		 * @param c 必选项，单个字符
		 * @return res 获得字符c在v中出现的次数
		 */
		charTime : function(v,c) {
			
			if (!utils.notEmpty(v) || v.length === 0) return "";
			var res = 0;
			for (var i=0,j=v.length; i<j; i++) {
				if (v.charAt(i) === c) {
					res ++;	
				}
			}
			(res === 0) && (res = ""); 
			return res;
		},
				
		/**
		 * 设置或移除控件的对齐方式
		 * @param bool 设置或移除对齐方式，true为增加，false为移除
		 * @return void
		 */
		textAlign : function(bool) {
			 
			var me = this,
				control = me.control,
				option = me.option,
				textAlign = option.textAlign;
			if (bool) {//增加对齐方式 	默认居右
				if(!utils.notEmpty(textAlign) || $.trim(textAlign).length === 0){
					textAlign = "right";
				}
				control.css("text-align",textAlign);
			} else {
				control.css("text-align","left");
			}
		},
		 
		value : function(value){
	
			var me = this,
				ct = me.control,
				opt = me.option;
			if(arguments.length){
				//给数据模型赋值（去掉千分位和金额货币符号）
				var currency = ct.currency,
					thoSep = opt.thousandsSeparator,
					res = value;
				if(utils.notEmpty(value) && $.trim(value).length !== 0){
					if(typeof(value) === "number"){
						value = String(value);
					}
					if((opt.chineseFormat || opt.format) && me.formatOrgVal){
						res = me.formatOrgVal;
					}
					//清除金额货币符号
					if(currency){
						var len = currency.length;
						res = value.substring(len);
					}
					//清除千分位分隔符
					if (utils.notEmpty(thoSep) && thoSep == true){
						res = me.removeCharFromString(v,",");
					}
				}
				ct.data("value",res);//负责往数据模型中设置值
				me.initValue(value, true);//负责控件值的显示
			} else {
				return ct.data("value");
			}
		},
		/**
		 * 设置显示值
		 * @param {String} value 值
		 * @param {Boolean} flag 从value方法过来的标识
		 */
		initValue : function(value, flag){
			var me = this;
			if(utils.notEmpty(value)){
				if(typeof(value) === "number"){
					value = value + "";
				}
				//小数部分不够补零的校验
				value = me.verifyDecimalDigit(value);
				var opt = me.option,
					cf = opt.chineseFormat;
				if( cf || opt.format){
					if(!me.doBlur){
						var val = "";
						if(!flag){
							val = value;
						}
						val = me.removeThousandsSeparator(val);
						//过滤大写金额和货币形式 1058595
						if(utils.notEmpty(val) && !isNaN(parseInt(val,10))){
							//移除百分比
							val = me.removePercent(val);
							me.formatOrgVal = value  = val;
						}else{
							me.formatOrgVal = value;
						}
						if(cf){
							switch( cf ){
								case "upper" : 
									value = utils.transferNumToChUpper(value);
									break;
								case "lower" :
									value = utils.transferNumToChLower(value);
									break;
								case "money" :
									value = utils.transferNumToMoney(value);
									break;
							}
						}else{
							value = utils.formatData(opt.format, value);
						}
						
					}else{
						delete me.doBlur;
					}
				}else{
					delete me.doBlur;
					//设置千分位
					value = me.addThousandsSeparator(value);
					//金额货币处理
					value = me.addMoneyCurrency(value);
				}
				//对齐方式
				me.textAlign(true);
			}else{
				delete me.formatOrgVal;
			}
			this.getControl().val(value);
			this.updateTitle(value);
		},
		getControl : function(){
			return this.control;
		},
		bind : function(event, handle){
			
			this.control.bind(event, handle);
		},
		unbind : function(event, handle){
			
			this.control.unbind(event, handle);
		},
		/**
		 * 更新提示
		 */
		updateTitle: function(v){
			var input = this.control;
			if(input && input.is("input") && !input.is(":password")){
				var t, vt;
				if(!arguments.length){
					v = input.val();
				}
				vt = typeof v;
				if( vt=== "undefined"){
					t = "";
				} else if(vt === "string"){
					t = v;
				} else if($.isArray(v)){
					t = v.join(",")
				} else {
					t = "";
				}
				t = t.length>200 ? t.substring(0,197).concat("...") : t;
				input.attr("title",t);
			}
		},
		removePercent: function(val){
			var value = ""+val;
			var index = value.indexOf("%");
			if(index >= 0){
				value = value.substring(0,index);
			}
			return value;
		},
		resizeWidth : function(width){
			if(typeof(width) === "string"){
				(width.indexOf("px") < 0) && (width = width + "px");
			}else if(typeof(width) !== "number"){
				width = "";
			}
			this.control.css("width",width);
		}
	};
	
	(function($) {
		var old = $.fn.numberBox;
		$.fn.numberBox = function(options){
			var me = this;
			options = options || {};
			var type = typeof(options);
			//如果第一个参数传入的是对象或空则初始化空件，如果传入的是字符串，则认为是调用里面的内部方法。
			if (type === "object") {
				var numBoxs = [];
				this.each(function() {
					var instanceOptions = $.extend({}, options, true);
					var instance = new NumberBox($(this), instanceOptions);
					this.numberBox = instance;
					numBoxs.push(instance);
				});
				if(numBoxs.length === 1){
					numBoxs = numBoxs[0];
				}
				return numBoxs;
			} else if (type === "string") {
				var args = Array.prototype.slice.call(arguments, 1);
				if (NumberBox.prototype[options]) {
					return NumberBox.prototype[options].call(args);
				}
			} else if (options === true) {
				return me[0] && me[0].numberBox;
			}
		};
		$.fn.numberBox.Constructor = NumberBox;
		$.fn.numberBox.noConflict = function() {
			$.fn.numberBox = old;
			return this;
		};
	}(jQuery));
	return NumberBox.prototype;
	
})
		
	
